Predicting NHL Goals Based Off Of Shot Characteristics¶

shots_sm.head()

skaters_sm_all["shotPct"] = skaters_sm_all["I_F_goals"] / skaters_sm_all["I_F_shotsOnGoal"] * 100

skaters_sm_all.head()

goalies_sm_all = goalies_sm.loc[goalies_sm["situation"] == "all"]
goalies_sm_all["savePct"] = (1-(goalies_sm_all["goals"] / goalies_sm_all["ongoal"])) * 100

goalies_sm_all.head()

shots_sm_og.head()

shots_sm_og.info()

shots_sm_og.shotType.value_counts()

from sklearn.impute import SimpleImputer

imputeShots = SimpleImputer(strategy='most_frequent')
shots_sm_og[["shotType"]] = imputeShots.fit_transform(shots_sm_og[["shotType"]])

shots_sm_og.shotType.value_counts()

shots_sm_og[shots_sm_og["shotPct"].isnull()]

shots_sm_og.head()

rink=NHLRink()
my_colors = ['#87cefa', '#ff0000']

fig, axs = plt.subplots(1, 1, figsize=(16, 12))
rink.plot_fn(sns.scatterplot, x="xCord", y="yCord", hue="goal", legend=True, data=shots_sm_og, ax=axs,palette=my_colors);

axs.set_title('Goal or Save?', fontsize=18)
axs.legend(title="Goal", bbox_to_anchor=(0.02, 0.98))

fig1, ax1 = plt.subplots(1, 1, figsize=(10,5))

sns.kdeplot(data=shots_sm_og, x="shotDistance", hue="goal", ax=ax1)

rink2=NHLRink()

fig, axs = plt.subplots(1, 1, figsize=(16, 12))
rink.plot_fn(sns.scatterplot, x="xCord", y="yCord", hue="shotType", legend=True, data=goal_sm_og, ax=axs);

axs.set_title('What scores?', fontsize=14)
axs.legend(title="Shot Type", bbox_to_anchor=(0.02, 0.98))

shots_limited.describe()

goal_limited.describe()

corrs = shots_limited.corr()
plt.figure(figsize=(12, 10))
sns.heatmap(corrs, annot=True, cmap='coolwarm', fmt='.2f', linewidths=0.5)

corrs['goal'].sort_values(ascending=False)

cont_vars = X_train[["shotPct", "savePct", "shooterTimeOnIce", "timeSinceFaceoff", "shotAngleAdjusted", "shotDistance"]]

fig, ax1 = plt.subplots(1,1, figsize=(8, 8))

cont_vars.hist(bins=50, ax=ax1)

import numpy as np

fig, ax1 = plt.subplots(1,2, figsize=(10,5))

np.log(X_train['shooterTimeOnIce']+0.001).hist(ax=ax1[0], bins=50);
np.log(X_train['timeSinceFaceoff']+0.001).hist(ax=ax1[1], bins=50);

X_train.head()

from sklearn.tree import DecisionTreeClassifier

tree_goal = DecisionTreeClassifier(max_depth=4, random_state=55)

tree_goal.fit(X_train, y_train)

from sklearn.metrics import accuracy_score

y_preds = tree_goal.predict(X_train)
accuracy_score(y_train, y_preds)

from sklearn.model_selection import cross_val_score

tree_cval = cross_val_score(tree_goal, X_train, y_train, scoring="accuracy", cv=10)
print(tree_cval)
print(tree_cval.mean())

from sklearn.model_selection import GridSearchCV

params = {'min_samples_leaf': range(1,30)}

goal_tree2 = DecisionTreeClassifier(random_state=55, max_depth=5)

grid_search = GridSearchCV(goal_tree2, params, cv=10)
grid_search.fit(X_train, y_train)

print(grid_search.best_params_)

plt.plot(params['min_samples_leaf'], grid_search.cv_results_['mean_test_score'])

plt.xlabel('min_samples_leaf')
plt.ylabel('Accuracy')

new_goal_tree = grid_search.best_estimator_
y_pred_new = new_goal_tree.predict(X_train)

accuracy_new = accuracy_score(y_train, y_pred_new)
print(accuracy_new)

accuracy_score(y_train, y_pred_ada)

grid_search = GridSearchCV(ada_goals, params, cv=10, scoring='accuracy')
grid_search.fit(X_train, y_train)

print(grid_search.best_params_)

new_ada_tree = grid_search.best_estimator_
y_pred_ada = new_ada_tree.predict(X_train)

accuracy_ada_new = accuracy_score(y_train, y_pred_ada)
print(accuracy_ada_new)

for name, i in zip(X_train.columns, new_goal_tree.feature_importances_):
    print(name, ': ', i)

for name, i in zip(X_train.columns, new_ada_tree.feature_importances_):
    print(name, ': ', i)

goal_probs2 = new_goal_tree.predict_proba(X_train)
goal_probs2[:20]

goal_probs = new_ada_tree.predict_proba(X_train)
goal_probs[:20]

accuracy_score(y_train, y_pred_lr)

logit_cval = cross_val_score(lr_goals, X_train, y_train, scoring="accuracy", cv=10)
print(logit_cval)
print(logit_cval.mean())

params2 = {'C': [0.01, 0.05, 0.1, 0.5, 1, 2, 5, 10]}

lr_goals2 = LogisticRegression(random_state=55, penalty='l2')

grid_search2 = GridSearchCV(lr_goals2, params2, cv=10)
grid_search2.fit(X_train, y_train)

print(grid_search2.best_params_)

plt.plot(params2['C'], grid_search2.cv_results_['mean_test_score'])

plt.xlabel('C value')
plt.ylabel('Accuracy')

new_lr = grid_search2.best_estimator_
y_pred_new2 = new_lr.predict(X_train)

accuracy2 = accuracy_score(y_train, y_pred_new2)
print(accuracy2)

coefs = new_lr.coef_[0]

for name, i in zip(X_train.columns, coefs):
    print(name, ': ', i)

goal_prob_lr = new_lr.predict_proba(X_train)
goal_prob_lr[:20]

print(totalTrain)
print(totalTree)
print(totalBoosting)
print(totalLR)

y_pred_last = new_lr.predict(X_test)

accuracy_last = accuracy_score(y_test, y_pred_last)

print(accuracy_last)

test_prob_lr = new_lr.predict_proba(X_test)

testLR = sum(prob[1] for prob in test_prob_lr)
totalTest = sum(y_test)

print(totalTest)
print(testLR)

from sklearn.metrics import confusion_matrix

# [TN, FP]
# [FN, TP]

cm = confusion_matrix(y_test, y_pred_last)
print(cm)

fig, ax = plt.subplots(1, 1, figsize=(12,8))

ax.step(FPR, TPR, linewidth=2)
ax.plot([0,1], [0,1], '--', color = 'black')

fs = 12
ax.set_xlabel('1 - Specificity = 1 - TNR = FPR', fontsize=fs)
ax.set_ylabel('Sensitivity = TPR', fontsize=fs)
ax.tick_params(axis='both', labelsize=fs)

AUC = np.trapz(TPR, FPR)
ax.set_title('AUC = ' + str(round(AUC,4)))

Y = TPR
X = FPR

#Get closest to upper left
d_min = 999999999
for k in range(len(thresholds)):

    if k < len(X) and k < len(Y):
    #Euclidean distance to upper left:
        d = np.sqrt((0 - X[k])**2 + (1 - Y[k])**2)

        if (d < d_min):
            d_min = d
            k_opt = k

#Optimal threshold value?
k_opt = thresholds[k_opt]
print(k_opt)

from sklearn.metrics import precision_recall_curve

fig, ax = plt.subplots(1, 1, figsize=(12,8))

Precision, Recall, thresholds = precision_recall_curve(y_test, test_prob_lr[:,1])
ax.step(Recall, Precision, linewidth=2)
ax.grid()

fs = 12
ax.set_xlabel('Recall (Sensitivity)', fontsize=fs)
ax.set_ylabel('Precision (PPV)', fontsize=fs)
ax.tick_params(axis='both', labelsize=fs)

ax.set_title('Precision-Recall Curve')
ax.set_ylim([0, 1])
ax.set_xlim([0, 1])

from sklearn.preprocessing import StandardScaler

std_scaler = StandardScaler()
format_probs = (test_prob_lr[:,1]).reshape(-1,1)
scaled_goal_probs = std_scaler.fit_transform(format_probs)

print(scaled_goal_probs)

X_test_heat = X_test.copy()
X_test_heat['new_Probs'] = scaled_goal_probs
X_test_heat['old_Probs'] = test_prob_lr[:,1]

X_heat_wcoords = pd.merge(X_test_heat, shots_sm_og[['xCord', 'yCord', 'shotType']], left_index=True, right_index=True)

X_heat_wcoords.head()

rink3=NHLRink()

fig, axs = plt.subplots(1, 1, figsize=(16, 12))
rink3.plot_fn(sns.scatterplot, x="xCord", y="yCord", hue="new_Probs", legend=False, data=X_heat_wcoords, ax=axs, palette="inferno");
axs.set_title('Goal Probs by Location', fontsize=18)

rink4=NHLRink()
fig, axs = plt.subplots(1, 1, figsize=(12, 8))

rink4.heatmap(
    "xCord", "yCord", "new_Probs", data=X_heat_wcoords, 
    binsize=4, fill_value=0, plot_xlim=(25, 89), cmap="inferno", vmax=0.6,
    ax=axs, draw_kw={"display_range": "ozone"},)

high_chance.head()

rink5=NHLRink()

fig, axs = plt.subplots(1, 1, figsize=(16, 12))
rink5.plot_fn(sns.scatterplot, x="xCord", y="yCord", hue="shotType", legend=True, data=high_chance, ax=axs);

axs.legend(title="Shot Type", bbox_to_anchor=(0.02, 0.98))